home *** CD-ROM | disk | FTP | other *** search
/ NeXTSTEP 3.1 (Developer) [x86] / NeXT Step 3.1 Intel dev.cdr.dmg / NextDeveloper / Examples / IndexingKit / StoreFile / StoreManager.m < prev   
Text File  |  1992-07-19  |  10KB  |  406 lines
  1. /*
  2. StoreManager.m - Copyright (c) 1992 NeXT Computer, Inc.
  3.  
  4. You may freely copy, distribute and reuse the code in this example.
  5. NeXT Computer, Inc. disclaims any warranty of any kind, expressed or implied, 
  6. as to its fitness for any particular use.
  7. */
  8.  
  9. #import <appkit/appkit.h>
  10. #import <sys/param.h>
  11. #import <bsd/libc.h>
  12. #import <objc/NXBundle.h>
  13. #import <store/IXStoreBlock.h>
  14. #import "DataWrapper.h"
  15. #import "StoreManager.h"
  16.  
  17. @interface StoreManager(Private)
  18.  
  19. - loadNib;
  20. - (int)browser:sender fillMatrix:matrix inColumn:(int)column;
  21. - browserClick:sender;
  22. - setBrowser:anObject;
  23. - windowWillClose:sender;
  24. - clearText;
  25. - appendToText:(const char *)aString;
  26.  
  27. @end
  28.  
  29. @implementation StoreManager(Private)
  30. - loadNib
  31. {
  32.     char buf[MAXPATHLEN+1];
  33.     NXBundle *aBundle = [NXBundle bundleForClass:[self class]];
  34.  
  35.     if ([aBundle getPath:buf forResource:"StoreManager" ofType:"nib"]) {
  36.      if ([NXApp loadNibFile:buf owner:self 
  37.     withNames:NO fromZone:[NXApp zone]]) {
  38.     [win makeKeyAndOrderFront:self];
  39.     [win setDelegate:self];
  40.     return self;
  41.      }
  42.     }
  43.  
  44.     return nil;
  45. }
  46.  
  47. - (int)browser:sender fillMatrix:matrix inColumn:(int)column
  48. {
  49.     int     row;
  50.     id        cell;
  51.     char    str[512];
  52.     int        cnt = [blocks count];
  53.  
  54.     for (row=0; row < cnt; row++) {
  55.     int        theValue;
  56.     DataWrapper    *aWrapper;
  57.     unsigned int    blockNum;
  58.     
  59.     blockNum = (unsigned int) [[blocks objectAt:row] value];
  60.     aWrapper = (DataWrapper *) 
  61.         IXReadObjectFromStore(storeFile, blockNum, [NXApp zone]);
  62.     [storeFile closeBlock:blockNum]; // not required for single context
  63.     theValue = [aWrapper value];
  64.     [aWrapper free];
  65.     
  66.     cell = [matrix cellAt:row :0];
  67.     if (cell == nil) {
  68.         [matrix insertRowAt:row];
  69.         cell = [matrix cellAt:row :0];
  70.     }
  71.     
  72.     sprintf(str, "%8d\t%8d\t%s",
  73.         [[blocks objectAt:row] value],
  74.         theValue,
  75.         [[blocks objectAt:row] key]);
  76.     [cell setStringValue:str];
  77.     [cell setLoaded:YES];
  78.     [cell setLeaf:YES];
  79.     }
  80.  
  81.     return row;
  82. }
  83.  
  84. - browserClick:sender
  85. {
  86.     int     row;
  87.     const char *str;
  88.     int        block, value;
  89.     const char    *key;
  90.  
  91.     str = [[[browser matrixInColumn:0] selectedCell] stringValue];
  92.     row = [[browser matrixInColumn:0] selectedRow];
  93.     sscanf(str, "%8d\t%8d", &block, &value);
  94.     /*
  95.     * the key starts at the first char after the first two tabs
  96.     */
  97.     key = [[blocks objectAt:row] key];
  98.  
  99.     [[keyForm cellAt:0 :0] setStringValue:key];
  100.     [[keyForm cellAt:1 :0] setIntValue:value];
  101.  
  102.     return self;
  103. }
  104.  
  105. - setBrowser:anObject
  106. {
  107.     [anObject setTarget:self];
  108.     [anObject setAction:@selector(browserClick:)];
  109.     [anObject setDoubleAction:@selector(browserClick:)];
  110.     browser = anObject;
  111.     return self;
  112. }
  113.  
  114. - windowWillClose:sender
  115. {
  116.     [self free];
  117.     [win setDelegate:nil];
  118.     return (id) 1;
  119. }
  120.  
  121. - clearText
  122. {
  123.     [text setText:""];
  124.     [text display];
  125.     return self;
  126. }
  127.  
  128. - appendToText:(const char *)aString
  129. {
  130.     int currentLength = [text textLength];
  131.     [text setSel:currentLength :currentLength];
  132.     [text replaceSel:aString];
  133.     [text scrollSelToVisible];
  134.  
  135.     return self;
  136. }
  137. @end
  138.  
  139. @implementation StoreManager
  140.  
  141. - init
  142. {
  143.     [super init];
  144.     blocks = [[List alloc] init];
  145.     return self;
  146. }
  147.  
  148. - add:sender
  149. {
  150.     unsigned int    newBlock;
  151.     DataWrapper        *aWrapper = [[DataWrapper alloc] init];
  152.  
  153.     /*
  154.     * get the values from the keyForm
  155.     */
  156.     [aWrapper setKey:[[keyForm cellAt:0 :0] stringValue]];
  157.     [aWrapper setValue:[[keyForm cellAt:1 :0] intValue]];
  158.  
  159.     /*
  160.     * get a new object and store it -- also update the list object
  161.     * initial size doesn't matter; size will be adjusted as needed when
  162.     * the wrapper is archived
  163.     */
  164.     if ([storeFile createBlock:&newBlock ofSize:1]) {
  165.     IXWriteRootObjectToStore(storeFile, newBlock, aWrapper);
  166.     [storeFile closeBlock:newBlock];
  167.     
  168.     /*
  169.      * we will reuse aWrapper as an auxilliary. 
  170.      * also store the list of blocks.
  171.      */
  172.     [aWrapper setValue:newBlock];
  173.     [blocks addObject:aWrapper];
  174.     IXWriteRootObjectToStore(storeFile, 1, blocks);
  175.     [win setDocEdited:YES];
  176.     [browser loadColumnZero];
  177.     } else {
  178.     NXRunAlertPanel([NXApp appName], 
  179.         "Add operation failed", "OK", NULL, NULL);
  180.     return nil;
  181.     }
  182.  
  183.     [keyForm selectTextAt:0 :0];
  184.     return self;
  185. }
  186.  
  187. - delete:sender
  188. {
  189.     unsigned int num = [[browser matrixInColumn:0] selectedRow];
  190.     DataWrapper *aWrapper = [blocks objectAt:num];
  191.  
  192.     if (!aWrapper) {
  193.     NXRunAlertPanel([NXApp appName],
  194.     "You must select a row to delete", "OK", NULL, NULL);
  195.     return nil;
  196.     }
  197.  
  198.     [blocks removeObjectAt:num];
  199.     [storeFile freeBlock:(unsigned int)[aWrapper value]];
  200.     IXWriteRootObjectToStore(storeFile, 1, blocks);
  201.     [aWrapper free];
  202.     [browser loadColumnZero];
  203.     return self;
  204. }
  205.  
  206. /*
  207.  * Verify the first twenty blocks...
  208.  */
  209. - verify:sender
  210. {
  211.     BOOL            found;
  212.     unsigned int        size;
  213.     unsigned int        i, cnt;
  214.     char            buffer[512];
  215.     
  216.     [self clearText];
  217.     [self appendToText:"VERIFYING FIRST TWENTY ENTRIES\n"];
  218.     for (i = 0; i < 20; i++) {
  219.     NX_DURING
  220.     if (size = [storeFile sizeOfBlock:i]) {
  221.         /*
  222.          * block exists... does it exist in blocks?
  223.          */
  224.         int count = [blocks count];
  225.         for (cnt=0, found = NO; cnt < count; cnt++) {
  226.         if ([[blocks objectAt:cnt] value] == i) {
  227.             /* block found */
  228.             found = YES;
  229.             sprintf(buffer,
  230.             "Block %u exists - found in list; size:%u\n", i, size);
  231.             [self appendToText:buffer];
  232.             break;
  233.         }
  234.         }
  235.     
  236.         if (found == NO) {
  237.         DataWrapper *aWrapper;
  238.         if (i == 1) {
  239.             /* This is the boot block */
  240.             sprintf(buffer,
  241.             "Block 1 is the boot block; size:%u\n", size);
  242.             [self appendToText:buffer];
  243.         } else {
  244.             aWrapper = (DataWrapper *) 
  245.             IXReadObjectFromStore(storeFile, i, [NXApp zone]);
  246.             [storeFile closeBlock:i];
  247.             sprintf(buffer, 
  248.             "Block %u exists - not in list; key=\"%s\" value=%d size:%u\n",
  249.             i, [aWrapper key], [aWrapper value], size);
  250.             [self appendToText:buffer];
  251.             [aWrapper free];
  252.         }
  253.         }
  254.     }
  255.     NX_HANDLER
  256.         /*
  257.          * If this were a multi-threaded application we should check
  258.          * the exception code, to see if indeed the block does not exist.
  259.          * Since it is single-threaded, it only raises the exception if
  260.          * the block does not exist...
  261.          */
  262.         sprintf(buffer, "Block %u does not exist *****\n", i);
  263.         [self appendToText:buffer];
  264.     NX_ENDHANDLER
  265.     }
  266.     
  267.     return self;
  268. }
  269.  
  270. - refresh:sender
  271. {
  272.     [browser loadColumnZero];
  273.     return self;
  274. }
  275.  
  276. - replace:sender
  277. {
  278.     const char    *str;
  279.     int        block, value;
  280.     DataWrapper    *aWrapper = [[DataWrapper alloc] init];
  281.     
  282.     str = [[[browser matrixInColumn:0] selectedCell] stringValue];
  283.     if (!str) {
  284.     NXRunAlertPanel([NXApp appName],
  285.         "You must select a row to replace", "OK", NULL, NULL);
  286.     return nil;
  287.     }
  288.  
  289.     sscanf(str, "%8d\t%8d", &block, &value);
  290.     
  291.     [aWrapper setKey:[[keyForm cellAt:0 :0] stringValue]];
  292.     [aWrapper setValue:[[keyForm cellAt:1 :0] intValue]];
  293.  
  294.     IXWriteRootObjectToStore(storeFile, (unsigned int)block, aWrapper);
  295.     [storeFile closeBlock:block];
  296.     
  297.     [[blocks objectAt:[[browser matrixInColumn:0] selectedRow]]
  298.     setKey:[aWrapper key]];
  299.     [aWrapper free];
  300.  
  301.     /*
  302.     * also write the list of blocks...
  303.     */
  304.     IXWriteRootObjectToStore(storeFile, 1, blocks);      
  305.     [browser loadColumnZero];
  306.     return self;
  307. }
  308.  
  309. - new:sender
  310. {
  311.     unsigned int    blockHandle;
  312.     
  313.     /*
  314.     * force it to create a storeFile
  315.     */
  316.     [self saveAs:self];
  317.     if (!storeFile) {
  318.     NXRunAlertPanel([NXApp appName],
  319.         "Cannot create a new IXStoreFile", "OK", NULL, NULL);
  320.     return nil;
  321.     }
  322.     
  323.     /*
  324.     * the first block that we allocate is always block 1, and we use this as
  325.     * our boot block. In this case, it is a bare bones example, and we will
  326.     * use the boot block to store the list blocks which enumerate the blocks
  327.     * we have allocated so far. The list is kept consistent with the store.
  328.     */
  329.     if (![storeFile createBlock:&blockHandle ofSize:1]) {
  330.     /* could not get a handle */
  331.     NXRunAlertPanel([NXApp appName],
  332.         "Cannot create the boot block", "OK", NULL, NULL);
  333.     [storeFile free];
  334.     return nil;
  335.     }
  336.     
  337.     /*
  338.     * At this point, we don't care to do anything else... we have opened
  339.     * a store, allocated block 1 (which we will use as our boot block),
  340.     * and we have created a List (not yet associated with the boot block).
  341.     */
  342.     
  343.     if (![self loadNib]) {
  344.     NXRunAlertPanel([NXApp appName],
  345.         "Cannot load the store file", "OK", NULL, NULL);
  346.     return nil;
  347.     }
  348.     
  349.     [win setTitle:[storeFile filename]];
  350.     [browser loadColumnZero];
  351.     return self;
  352. }
  353.  
  354. char *storeFileTypes[] = { "store", 0 };
  355.  
  356. - open:sender
  357. {
  358.     id        openPanel = [OpenPanel new];
  359.     
  360.     if ([openPanel runModalForTypes:storeFileTypes]) {
  361.     storeFile = [[IXStoreFile alloc] 
  362.         initFromFile:[openPanel filename] forWriting:YES];
  363.     if (!storeFile) {
  364.         NXRunAlertPanel([NXApp appName],
  365.         "Cannot open the IXStoreFile", "OK", NULL, NULL);
  366.         return [self free];
  367.     }
  368.     }
  369.     
  370.     /*
  371.     * load the blocks list from the boot block
  372.     */
  373.     blocks = (List *) IXReadObjectFromStore(storeFile, 1, [NXApp zone]);
  374.     
  375.     [self loadNib];
  376.     [win setTitle:[storeFile filename]];
  377.     [browser loadColumnZero];
  378.     return self;
  379. }
  380.  
  381. - saveAs:sender
  382. {
  383.     id        savePanel = [SavePanel new];
  384.  
  385.     [savePanel setRequiredFileType:"store"];
  386.     if (![savePanel runModalForDirectory:"." file:"testfile.store"]) {
  387.     NXRunAlertPanel([NXApp appName],
  388.         "You must save to create a new IXStoreFile", "OK", NULL, NULL);
  389.     return nil;
  390.     }
  391.  
  392.     storeFile = [[IXStoreFile alloc] initWithFile:[savePanel filename]];
  393.     return self;
  394. }
  395.  
  396. - free
  397. {
  398.     [blocks free];
  399.     [storeFile commitTransaction];
  400.     [storeFile free];
  401.     return [super free];
  402. }
  403.  
  404. @end
  405.  
  406.